//public class Test {
//    public static void main(String[] args) {
//        int a=10;
//        int b=++a;
//        /*int b=a++; 和c语言中一样,前置++和后置++ */
//        System.out.println(a);
//        System.out.println(b);
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        int a=10;
//        int b=20;
//        // 注意：在Java中 = 表示赋值，要与数学中的含义区分
//        // 在Java中 == 表示相等
//        System.out.println(a == b); // false
//        System.out.println(a != b); // true
//        System.out.println(a < b); // true
//        System.out.println(a > b); // false
//        System.out.println(a <= b); // true
//        System.out.println(a >= b); // false
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        //逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。
//        //逻辑与&&的表达式是: 布尔表达式1 && 布尔表达式2 (只要有一个表达式为假,结果就为假(false))
//        //两个表达式同时为真,结果就为真(true)
//        //逻辑或||的表达式是: 布尔表达式1 || 布尔表达式2 (只要有一个表达式为真,结果就为真(true))
//        //两个表达式同时为假,结果就为假(false)
//
//        //&&和||遵循短路求值的规则
//        int a=1;
//        int b=2;
//        System.out.println(a>b && 10/0==0);//对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
//        System.out.println(a<b || 10/0==0);//对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
//        //我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值
//
//        //逻辑非!的表达式是: !布尔表达式
//        System.out.println(!true);//false
//        System.out.println(!false);//true
//
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        //按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0
//        int a = 10;
//        int b = 20;
//        System.out.println(a & b);
//        //进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100
//        //0001010 -> 10的二进制
//        //0010100 -> 20的二进制
//        //0000000 -> 0的二进制
//
//        //按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1
//        int c = 10;
//        int d = 20;
//        System.out.println(c | d);
//        //进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100
//        //0001010 -> 10的二进制
//        //0010100 -> 20的二进制
//        //0011110 -> 30的二进制
//
//        //按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.
//        int e = 0x1;
//        int f = 0x2;
//        System.out.printf("%x\n", e ^ f);
//        //进行按位运算, 需要先把 0x1 和 0x2 转成二进制, 分别为 00000001 和 00000010
//        //01
//        //10
//        //11
//        //总结了一个规律:
//        //n^n=0
//        //0^n=n
//
//        //按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
//        int h = 0xf;
//        System.out.printf("%x\n", ~h);
//        //进行按位运算, 需要先把 0xf 转成二进制
//        //0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4个二进制位.
//        //0xf 表示 10 进制的 15, 也就是二进制的 1111
//        //printf 能够格式化输出内容, %x 表示按照十六进制输出.  注意 \n 表示换行符
//
//        //所以这种不存在短路
//        System.out.println(10 < 20 & 10 > 0);//都为真
//        System.out.println(10 > 20 & 10 > 0);//第一个为假
//        System.out.println(10 < 20 & 10 < 0);//第二个为假
//        System.out.println(10 > 20 & 10 < 0);//都为假
//
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//       // 移位运算符有三个: <<(左移) >>(右移) >>>(无符号右移) ，都是二元运算符，且都是按照二进制比特位来运算的。
//        // 左移 <<: 最左侧位不要了, 最右侧补 0
//        int a = 0x10;
//        System.out.printf("%x\n", a << 1);//20
//        // 运行结果(注意, 是按十六进制打印的)
//        //举个例子:
//        //0000 1011 -> 11
//        //0000 1011 << 1 左移1个比特位
//        //向左边移动 那么 右边补0 -> 0(丢弃了) 000 1 0110 -> 22
//        //0000 1011 << 2 左移2个比特位
//        //00(丢弃了)00 10 1100 -> 44
//        //n*2^x = 11*2^1 =22
//
//        //右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
//        int b = 0x10;
//        System.out.printf("%x\n", b >> 1);
//        // 运行结果(注意, 是按十六进制打印的)
//        //举个例子:
//        //0000 1011 -> 11
//        //0000 1011 >> 1 右移1个比特位 -> 0(补的符号位)000 0 101(1舍弃的) = 5  11/2^1
//        //0000 1011 >> 2 右移2个比特位 ->00(补的符号位)00 00 10(11舍弃的) = 2  11/2^2
//        //n/2^x
//
//        //无符号右移 >>>: 最右侧位不要了, 最左侧补 0
//        int d = 0xffffffff;
//        System.out.printf("%x\n", d >>> 1);
//        // 运行结果(注意, 是按十六进制打印的)
//        //举个例子:
//        // 1111 1111 -> -1
//        // 1111 1111 >>>1  -> 0(无符号右移直接补0)111 1 111(1舍弃了)
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        //条件运算符只有一个:
//        //表达式1 ? 表达式2 : 表达式3
//        //当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
//        //当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
//        //也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.
//        // 例题求两个整数的最大值
//        int a = 10;
//        int b = 20;
//        int max = a > b ? a : b;
//        System.out.println(max);
//
//        //再来一个例题
//        boolean flg= true==true?true == false?false:true:false;
//        System.out.println(flg);
//        //通过这个例题可以看出来,运算符的优先级
//        //如果你不知道优先级是什么,那你就把它用括号()括起来
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        //分支结构
//        /*
//        if(布尔表达式){
//        // 语句
//        }
//        */
//        //如果布尔表达式结果为true，执行if中的语句，否则不执行。
//        //比如：小明，如果这次考试考到90分或以上，给你奖励一个鸡腿。
////        int score = 92;
////        if(score >= 90){
////            System.out.println("吃个大鸡腿!!!");
////        }
////    }
//    /*
//    if(布尔表达式){
//    // 语句1
//    }else{
//    // 语句2
//    }
//    如果布尔表达式结果为true，则执行if中语句，否则执行else中语句。
//    */
//        //比如：小明，如果这次考到90分以上，给你奖励一个大鸡腿，否则奖你一个大嘴巴子。
//        /*int score = 92;
//        if (score >= 90) {
//            System.out.println("吃个大鸡腿!!!");
//        } else {
//            System.out.println("给你个大嘴巴子");
//        }*/
//
//
//    }
//}

//计算1！+2！+...+5!
//public class Test {
//    public static void main(String[] args) {
//        int j=1;
//        int sum=0;
//        while(j<=5){
//            int i=1;
//            int ret=1;
//            while(i<=j){
//                ret*=i;
//                i++;
//            }
//            j++;
//            sum+=ret;
//        }
//        System.out.println(sum);
//    }
//}

//求出 1-100之间 所以既能被3 也能被5 整除的数字 要使用break 或者 continue 做
//public class Test {
//    public static void main(String[] args) {
//        int i=1;
//        while(i<=100){
//            if(i%15!=0){
//                i++;
//                continue;
//            }
//            System.out.println(i);
//            i++;
//        }
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*for(表达式①;布尔表达式②;表达式③){
//            表达式④;
//        }*/
//        //例题 打印1-100之间的数字
//        for (int i=1;i<=100;i++){
//            System.out.println(i);
//        }
//    }
//}

//计算1！+2！+...+5!
//public class Test {
//    public static void main(String[] args) {
//        int sum=0;
//        for (int j = 0; j <=5 ; j++) {
//            int ret=1;
//            for (int i = 1; i <=j ; i++) {
//                ret*=i;
//            }
//            sum+=ret;
//        }
//        System.out.println(sum);
//    }
//}